const db = require('../../models/index');
const DAO = require('../../dao/sql-option-dao');
const logger = require('../../utils/logger-util');
const Comments = db.comments;
const Article = db.article;
const Users = db.users;
const { COMMENTS_TYPE } = require("../../constants/system/user-constants");

// 用户-评论 一对多关系
Users.hasMany(Comments, {
    foreignKey: 'userId',
    sourceKey: 'id'
});
Comments.belongsTo(Users, {
    foreignKey: 'userId',
    sourceKey: 'id'
});

// ========================= 创建评论 =========================
// 更新评论数
/**
 *  model: 数据模型
 *  queryField：需要查询的字段
 *  updateField: 需要更改的字段
 * 
*/
async function createCommentCount(model, queryField, updateField) {
    // 查询信息
    let fOneInfo = await model.findOne({ where:{ id: queryField } });
    let commentCount = parseInt(fOneInfo[updateField]);
    let updateParam = {
        [updateField]: commentCount + 1
    };
    await model.update(updateParam, { where:{ id: fOneInfo.id} });
};
// 创建
exports.create = (req, res) => {
    try {
        const createInfo = req.body;
        // 不是文章评论时
        if(createInfo.type != COMMENTS_TYPE.ARTICLE.value) {
            // 创建评论
            DAO.create(Comments, createInfo, async data => {
                // 更新用户评论数
                await createCommentCount(Users, createInfo.userId, 'commentsCount');
                res.sendResult(data);
            })
            return;
        };
        // 创建评论
        DAO.create(Comments, createInfo, async data => {
            // 评论数加1
            // 更新用户评论数
            await createCommentCount(Users, createInfo.userId, 'commentsCount');
            // 更新文章评论数
            await createCommentCount(Article, createInfo.articleId, 'commentsCount');
            res.sendResult(data);
        })
    } catch (e) {
        console.log(e);
        logger.error(e);
        res.sendResultAto(null, 500, '服务器错误');
    }
};



// 查询评论列表
exports.findAll = async (req, res) => {
    const fAllInfo = req.body;
    let userAll = await Users.findAll();
    DAO.list(Comments, fAllInfo, list => {
        let commentData = list.data.data;
        userAll.forEach(item => {
            commentData.forEach(subItem => {
                if(item.id === subItem.userId) {
                    subItem.fromAvatar = item.avatar
                    subItem.fromNickname = item.nickname
                    subItem.fromUserId = item.userId
                }
                if(item.id === subItem.toUserKeyId) {
                    subItem.toAvatar = item.avatar
                    subItem.toNickname = item.nickname
                    subItem.toUserId = item.userId
                }
            })
        });
        res.sendResult(list);
    })
};

// 更新评论
exports.update = (req, res) => {
    const updateInfo = req.body;
    DAO.update(Comments, updateInfo, { id:updateInfo.id }, data => {
        res.sendResult(data);
    })
};

// ========================= 删除评论 =========================
// 更新评论数量
/**
 *  model: 数据模型
 *  queryField：需要查询的字段
 *  updateField: 需要更改的字段
 *  childIdCount: 子评论数量
 * 
*/
async function updateCommentCount(model, queryField, updateField, childIdCount) {
    // 查询信息
    let fOneInfo = await model.findOne({ where:{ id: queryField } });
    let commentCount = parseInt(fOneInfo[updateField]);
    let updateParam = null;
    if(childIdCount) {
        updateParam = {
            [updateField]: commentCount - childIdCount <= 0 ? 0 : commentCount - childIdCount
        };
    }else {
        updateParam = { 
            [updateField]: commentCount - 1 <= 0 ? 0 : commentCount - 1 
        }
    }
    await model.update(updateParam, { where:{ id: fOneInfo.id} });
};
// 删除
exports.delete = async (req, res) => {
    // 查询本条评论，拿到文章id和父评论id
    // 判断评论是否有回复
    // 是：就删除所有回复并删除本条评论
    // 查询本条评论下的所有子评论的数量，加上父评论
    // 先删除本条评论
    // 删除本条评论下的子评论 parentId = id的相同评论
    // 根据文章类别更新评论数量
    // 更新文章的评论数量
    // 否：删除本条评论
    // 更新文章评论数量
    try {
        const deleteInfo = req.body;
        let commentInfo = await Comments.findOne({ where:{ id:deleteInfo.id } });
        let articleId = commentInfo.articleId; // 文章id
        let parentId = commentInfo.parentId; // 父评论id
        let commentCount = 1; // 用于存放评论数 (1为本条评论)
        if(parseInt(parentId) !== 0) { // 否时
            // 删除本条评论
            let deleteParentData = await Comments.destroy({ where:{ id:deleteInfo.id } });
            // 不是文章评论时
            if(deleteInfo.type != COMMENTS_TYPE.ARTICLE.value) 
            return res.sendResultAto(deleteParentData, 200, '删除评论成功！');
            // 更新文章评论数量
            await updateCommentCount(Article, articleId, 'commentsCount',);
            // 更新用户评论数量
            await updateCommentCount(Users, deleteInfo.userId, 'commentsCount',);
            // // 更新文章评论数量
            // let fOneArticle = await Article.findOne({ where:{ id:articleId } });
            // let articleCommentCount = parseInt(fOneArticle.commentsCount);
            // // 删除评论数量时，数量重置为0 or 减1
            // let updateParam = {
            //     commentsCount: articleCommentCount - 1 <= 0 ? 0 : articleCommentCount - 1
            // };
            // // 更新文章评论数量
            // await Article.update(updateParam, { where:{ id: articleId} });
            // // 更新用户的评论数量
            // let userData = await Users.findOne({ where:{ id: deleteInfo.userId} });
            // let userCommentsCount = parseInt(userData.commentsCount);
            // let userUpdateParam = {
            //     commentsCount: userCommentsCount - 1 <= 0 ? 0 : userCommentsCount - 1
            // }
            // await Users.update(userUpdateParam, { where:{ id: userData.id} });
            res.sendResultAto(deleteParentData, 200, '删除评论成功！')
        } else { // 是：有子评论时
            // 查询本条评论下的所有子评论的数量
            let childIdCount = await Comments.findAndCountAll({ where: { parentId:deleteInfo.id } });
            // 存放评论数
            commentCount += childIdCount;
            // 删除子评论
            let destroyData = await Comments.destroy({ where: { parentId:deleteInfo.id } });
            // 删除本条评论
            await Comments.destroy({ where:{ id:deleteInfo.id } });
            // 不是文章评论时
            if(deleteInfo.type != COMMENTS_TYPE.ARTICLE.value) 
            return res.sendResultAto(destroyData, 200, '删除评论成功！');
            // // 查询文章信息
            // let fOneArticle = await Article.findOne({ where:{ id:articleId } });
            // // 当前文章评论数量
            // let articleCommentCount = parseInt(fOneArticle.commentsCount);
            // // 当前文章评论数量减去父子评论的总和 or 重置为0
            // let updateParam = {
            //     commentsCount: articleCommentCount - commentCount <= 0 ? 0 : articleCommentCount - commentCount
            // };
            // // 更新文章评论数量
            // await Article.update(updateParam, { where:{ id: articleId} });
            // 更新文章评论数量
            await updateCommentCount(Article, articleId, 'commentsCount', commentCount);
            // 更新用户评论数量
            await updateCommentCount(Users, deleteInfo.userId, 'commentsCount', commentCount);
            res.sendResultAto(destroyData, 200, '删除评论成功！');
        }
    } catch (e) {
        console.log(e);
        logger.error(e);
        res.sendResultAto(null, 500, '服务器错误，请联系管理员！');
    };
};